home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / HTFile.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  25KB  |  949 lines
  1. /*            File Access                HTFile.c
  2. **            ===========
  3. **
  4. **    This is unix-specific code in general, with some VMS bits.
  5. **    These are routines for file access used by WWW browsers.
  6. **
  7. ** History:
  8. **       Feb 91    Written Tim Berners-Lee CERN/CN
  9. **       Apr 91    vms-vms access included using DECnet syntax
  10. **    26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  11. **            Fixed access bug for relative names on VMS.
  12. **
  13. ** Bugs:
  14. **    FTP: Cannot access VMS files from a unix machine.
  15. **      How can we know that the
  16. **    target machine runs VMS?
  17. **
  18. **    DIRECTORIES are NOT SORTED.. alphabetically etc.
  19. */
  20.  
  21. #include "HTFile.h"        /* Implemented here */
  22.  
  23.  
  24. #define INFINITY 512        /* file name length @@ FIXME */
  25. #define MULTI_SUFFIX ".multi"   /* Extension for scanning formats */
  26.  
  27. #include <sys/fcntl.h>
  28. #include <sys/types.h>
  29. #include <dirent.h>
  30.  
  31. #ifdef _M_UNIX  /* for sco */
  32. #define   d_namlen  d_reclen
  33. #define NO_GROUPS
  34. #endif
  35.  
  36. #include "HTUtils.h"
  37.  
  38. #include "HTParse.h"
  39. #include "tcp.h"
  40. #include "HTTCP.h"
  41. #ifndef DECNET
  42. #include "HTFTP.h"
  43. #endif
  44. #include "HTAnchor.h"
  45. #include "HTAtom.h"
  46. #include "HTWriter.h"
  47. #include "HTFWriter.h"
  48. #include "HTInit.h"
  49.  
  50. typedef struct _HTSuffix {
  51.     char *        suffix;
  52.     HTAtom *    rep;
  53.     float        quality;
  54. } HTSuffix;
  55.  
  56.  
  57.  
  58. #ifdef unix            /* if this is to compile on a UNIX machine */
  59. #include "HTML.h"        /* For directory object building */
  60.  
  61. #define PUTC(c) (*targetClass.put_character)(target, c)
  62. #define PUTS(s) (*targetClass.put_string)(target, s)
  63. #define START(e) (*targetClass.start_element)(target, e, 0, 0)
  64. #define END(e) (*targetClass.end_element)(target, e)
  65. #define END_TARGET (*targetClass.end_document)(target)
  66. #define FREE_TARGET (*targetClass.free)(target)
  67. struct _HTStructured {
  68.     CONST HTStructuredClass *    isa;
  69.     /* ... */
  70. };
  71.  
  72. #endif                /* unix */
  73.  
  74.  
  75. /*                   Controlling globals
  76. **
  77. */
  78.  
  79. PUBLIC int HTDirAccess = HT_DIR_OK;
  80. PUBLIC int HTDirReadme = HT_DIR_README_TOP;
  81.  
  82. PRIVATE char *HTMountRoot = "/net/";        /* Where to find mounts */
  83. #ifdef vms
  84. PRIVATE char *HTCacheRoot = "/WWW$SCRATCH/";   /* Where to cache things */
  85. #else
  86. PRIVATE char *HTCacheRoot = "/tmp/W3_Cache_";   /* Where to cache things */
  87. #endif
  88.  
  89. /* PRIVATE char *HTSaveRoot  = "$(HOME)/WWW/";*/    /* Where to save things */
  90.  
  91.  
  92. /*    Suffix registration
  93. */
  94.  
  95. PRIVATE HTList * HTSuffixes = 0;
  96.  
  97. /*    Define the representation associated with a file suffix
  98. **    -------------------------------------------------------
  99. */
  100. PUBLIC void HTSetSuffix ARGS3(
  101.     CONST char *,    suffix,
  102.     CONST char *,    representation,
  103.     float,        value)
  104. {
  105.     
  106.     HTSuffix * suff = (HTSuffix*) calloc(1, sizeof(HTSuffix));
  107.     if (suff == NULL) outofmem(__FILE__, "HTSetSuffix");
  108.     
  109.     if (!HTSuffixes) HTSuffixes = HTList_new();
  110.     
  111.     StrAllocCopy(suff->suffix, suffix);
  112.     suff->rep = HTAtom_for(representation);
  113.     suff->quality = value;
  114.     HTList_addObject(HTSuffixes, suff);
  115. }
  116.  
  117.  
  118.  
  119.  
  120. #ifdef vms
  121. /*    Convert unix-style name into VMS name
  122. **    -------------------------------------
  123. **
  124. ** Bug:    Returns pointer to static -- non-reentrant
  125. */
  126. PRIVATE char * vms_name(CONST char * nn, CONST char * fn)
  127. {
  128.  
  129. /*    We try converting the filename into Files-11 syntax. That is, we assume
  130. **    first that the file is, like us, on a VMS node. We try remote
  131. **    (or local) DECnet access. Files-11, VMS, VAX and DECnet
  132. **    are trademarks of Digital Equipment Corporation. 
  133. **    The node is assumed to be local if the hostname WITHOUT DOMAIN
  134. **    matches the local one. @@@
  135. */
  136.     static char vmsname[INFINITY];    /* returned */
  137.     char * filename = (char*)malloc(strlen(fn)+1);
  138.     char * nodename = (char*)malloc(strlen(nn)+2+1);    /* Copies to hack */
  139.     char *second;        /* 2nd slash */
  140.     char *last;            /* last slash */
  141.     
  142.     char * hostname = HTHostName();
  143.  
  144.     if (!filename || !nodename) outofmem(__FILE__, "vms_name");
  145.     strcpy(filename, fn);
  146.     strcpy(nodename, "");    /* On same node? Yes if node names match */
  147.     {
  148.         char *p, *q;
  149.         for (p=hostname, q=nn; *p && *p!='.' && *q && *q!='.'; p++, q++){
  150.         if (TOUPPER(*p)!=TOUPPER(*q)) {
  151.             strcpy(nodename, nn);
  152.         q = strchr(nodename, '.');    /* Mismatch */
  153.         if (q) *q=0;            /* Chop domain */
  154.         strcat(nodename, "::");        /* Try decnet anyway */
  155.         break;
  156.         }
  157.     }
  158.     }
  159.  
  160.     second = strchr(filename+1, '/');        /* 2nd slash */
  161.     last = strrchr(filename, '/');    /* last slash */
  162.         
  163.     if (!second) {                /* Only one slash */
  164.     sprintf(vmsname, "%s%s", nodename, filename + 1);
  165.     } else if(second==last) {        /* Exactly two slashes */
  166.     *second = 0;        /* Split filename from disk */
  167.     sprintf(vmsname, "%s%s:%s", nodename, filename+1, second+1);
  168.     *second = '/';    /* restore */
  169.     } else {                 /* More than two slashes */
  170.     char * p;
  171.     *second = 0;        /* Split disk from directories */
  172.     *last = 0;        /* Split dir from filename */
  173.     sprintf(vmsname, "%s%s:[%s]%s",
  174.         nodename, filename+1, second+1, last+1);
  175.     *second = *last = '/';    /* restore filename */
  176.     for (p=strchr(vmsname, '['); *p!=']'; p++)
  177.         if (*p=='/') *p='.';    /* Convert dir sep.  to dots */
  178.     }
  179.     free(nodename);
  180.     free(filename);
  181.     return vmsname;
  182. }
  183.  
  184.  
  185. #endif /* vms */
  186.  
  187.  
  188.  
  189. /*    Send README file
  190. **
  191. **  If a README file exists, then it is inserted into the document here.
  192. */
  193.  
  194. #ifdef unix
  195. PRIVATE void do_readme ARGS2(HTStructured *, target, CONST char *, localname)
  196. { 
  197.     FILE * fp;
  198.     char * readme_file_name = 
  199.     malloc(strlen(localname)+ 1 + strlen(HT_DIR_README_FILE) + 1);
  200.     strcpy(readme_file_name, localname);
  201.     strcat(readme_file_name, "/");
  202.     strcat(readme_file_name, HT_DIR_README_FILE);
  203.     
  204.     fp = fopen(readme_file_name,  "r");
  205.     
  206.     if (fp) {
  207.     HTStructuredClass targetClass;
  208.     
  209.     targetClass =  *target->isa;    /* (Can't init agregate in K&R) */
  210.     START(HTML_PRE);
  211.     for(;;){
  212.         char c = fgetc(fp);
  213.         if (c == (char)EOF) break;
  214.         switch (c) {
  215.             case '&':
  216.         case '<':
  217.         case '>':
  218.             PUTC('&');
  219.             PUTC('#');
  220.             PUTC((char)(c / 10));
  221.             PUTC((char) (c % 10));
  222.             PUTC(';');
  223.             break;
  224.             case '\n':
  225.             PUTC('\r');    /* Fall through */
  226.         default:
  227.             PUTC(c);
  228.         }
  229.     }
  230.     END(HTML_PRE);
  231.     fclose(fp);
  232.     } 
  233. }
  234. #endif
  235.  
  236.  
  237. /*    Make the cache file name for a W3 document
  238. **    ------------------------------------------
  239. **    Make up a suitable name for saving the node in
  240. **
  241. **    E.g.    /tmp/WWW_Cache_news/1234@cernvax.cern.ch
  242. **        /tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
  243. **
  244. ** On exit,
  245. **    returns    a malloc'ed string which must be freed by the caller.
  246. */
  247. PUBLIC char * HTCacheFileName ARGS1(CONST char *,name)
  248. {
  249.     char * access = HTParse(name, "", PARSE_ACCESS);
  250.     char * host = HTParse(name, "", PARSE_HOST);
  251.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  252.     
  253.     char * result;
  254.     result = (char *)malloc(
  255.         strlen(HTCacheRoot)+strlen(access)
  256.         +strlen(host)+strlen(path)+6+1);
  257.     if (result == NULL) outofmem(__FILE__, "HTCacheFileName");
  258.     sprintf(result, "%s/WWW/%s/%s%s", HTCacheRoot, access, host, path);
  259.     free(path);
  260.     free(access);
  261.     free(host);
  262.     return result;
  263. }
  264.  
  265.  
  266. /*    Open a file for write, creating the path
  267. **    ----------------------------------------
  268. */
  269. #ifdef NOT_IMPLEMENTED
  270. PRIVATE int HTCreatePath ARGS1(CONST char *,path)
  271. {
  272.     return -1;
  273. }
  274. #endif
  275.  
  276. /*    Convert filenames between local and WWW formats
  277. **    -----------------------------------------------
  278. **    Make up a suitable name for saving the node in
  279. **
  280. **    E.g.    $(HOME)/WWW/news/1234@cernvax.cern.ch
  281. **        $(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
  282. **
  283. ** On exit,
  284. **    returns    a malloc'ed string which must be freed by the caller.
  285. */
  286. static char * HTLocalName ARGS1(CONST char *,name)
  287. {
  288.     char * access = HTParse(name, "", PARSE_ACCESS);
  289.     char * host = HTParse(name, "", PARSE_HOST);
  290.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  291.    
  292.     HTUnEscape(path);    /* Interpret % signs */
  293.     
  294.     if (0==strcmp(access, "file")) {
  295.         free(access);    
  296.     if ((0==strcmp(host, HTHostName())) || !*host) {
  297.         free(host);
  298.         if (TRACE) fprintf(stderr, "Node `%s' means path `%s'\n", name, path);
  299.         return(path);
  300.     } else {
  301.         char * result = (char *)malloc(
  302.                     strlen("/Net/")+strlen(host)+strlen(path)+1);
  303.               if (result == NULL) outofmem(__FILE__, "HTLocalName");
  304.         sprintf(result, "%s%s%s", "/Net/", host, path);
  305.         free(host);
  306.         free(path);
  307.         if (TRACE) fprintf(stderr, "Node `%s' means file `%s'\n", name, result);
  308.         return result;
  309.     }
  310.     } else {  /* other access */
  311.     char * result;
  312.         CONST char * home =  (CONST char*)getenv("HOME");
  313.     if (!home) home = "/tmp"; 
  314.     result = (char *)malloc(
  315.         strlen(home)+strlen(access)+strlen(host)+strlen(path)+6+1);
  316.       if (result == NULL) outofmem(__FILE__, "HTLocalName");
  317.     sprintf(result, "%s/WWW/%s/%s%s", home, access, host, path);
  318.     free(path);
  319.     free(access);
  320.     free(host);
  321.     return result;
  322.     }
  323. }
  324.  
  325.  
  326. /*    Make a WWW name from a full local path name
  327. **
  328. ** Bugs:
  329. **    At present, only the names of two network root nodes are hand-coded
  330. **    in and valid for the NeXT only. This should be configurable in
  331. **    the general case.
  332. */
  333.  
  334. PUBLIC char * WWW_nameOfFile ARGS1 (CONST char *,name)
  335. {
  336.     char * result;
  337. #ifdef NeXT
  338.     if (0==strncmp("/private/Net/", name, 13)) {
  339.     result = (char *)malloc(7+strlen(name+13)+1);
  340.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  341.     sprintf(result, "file://%s", name+13);
  342.     } else
  343. #endif
  344.     if (0==strncmp(HTMountRoot, name, 5)) {
  345.     result = (char *)malloc(7+strlen(name+5)+1);
  346.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  347.     sprintf(result, "file://%s", name+5);
  348.     } else {
  349.         result = (char *)malloc(7+strlen(HTHostName())+strlen(name)+1);
  350.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  351.     sprintf(result, "file://%s%s", HTHostName(), name);
  352.     }
  353.     if (TRACE) fprintf(stderr, "File `%s'\n\tmeans node `%s'\n", name, result);
  354.     return result;
  355. }
  356.  
  357.  
  358. /*    Determine a suitable suffix, given the representation
  359. **    -----------------------------------------------------
  360. **
  361. ** On entry,
  362. **    rep    is the atomized MIME style representation
  363. **
  364. ** On exit,
  365. **    returns    a pointer to a suitable suffix string if one has been
  366. **        found, else "".
  367. */
  368. PUBLIC CONST char * HTFileSuffix ARGS1(HTAtom*, rep)
  369. {
  370.     HTSuffix * suff;
  371.     int n;
  372.     int i;
  373.  
  374. #ifndef NO_INIT    
  375.     if (!HTSuffixes) HTFileInit();
  376. #endif
  377.     n = HTList_count(HTSuffixes);
  378.     for(i=0; i<n; i++) {
  379.     suff = HTList_objectAt(HTSuffixes, i);
  380.     if (suff->rep == rep) {
  381.         return suff->suffix;        /* OK -- found */
  382.     }
  383.     }
  384.     return "";        /* Dunno */
  385. }
  386.  
  387.  
  388. /*    Determine file format from file name
  389. **    ------------------------------------
  390. **
  391. */
  392.  
  393. PUBLIC HTFormat HTFileFormat ARGS1 (CONST char *,filename)
  394.  
  395. {
  396.     HTSuffix * suff;
  397.     int n;
  398.     int i;
  399.     int lf = strlen(filename);
  400.  
  401. #ifndef NO_INIT    
  402.     if (!HTSuffixes) HTFileInit();
  403. #endif
  404.     n = HTList_count(HTSuffixes);
  405.     for(i=0; i<n; i++) {
  406.         int ls;
  407.     suff = HTList_objectAt(HTSuffixes, i);
  408.     ls = strlen(suff->suffix);
  409.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  410.         return suff->rep;        /* OK -- found */
  411.     }
  412.     }
  413.     return strchr(filename, '.') ? WWW_BINARY : WWW_PLAINTEXT;    /* Dunno */
  414. }
  415.  
  416.  
  417. /*    Determine value from file name
  418. **    ------------------------------
  419. **
  420. */
  421.  
  422. PUBLIC float HTFileValue ARGS1 (CONST char *,filename)
  423.  
  424. {
  425.     HTSuffix * suff;
  426.     int n;
  427.     int i;
  428.     int lf = strlen(filename);
  429.  
  430. #ifndef NO_INIT    
  431.     if (!HTSuffixes) HTFileInit();
  432. #endif
  433.     n = HTList_count(HTSuffixes);
  434.     for(i=0; i<n; i++) {
  435.         int ls;
  436.     suff = HTList_objectAt(HTSuffixes, i);
  437.     ls = strlen(suff->suffix);
  438.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  439.         if (TRACE) fprintf(stderr, "File: Value of %s is %.3f\n",
  440.                    filename, suff->quality);
  441.         return suff->quality;        /* OK -- found */
  442.     }
  443.     }
  444.     return 0.3;        /* Dunno! */
  445. }
  446.  
  447.  
  448. /*    Determine write access to a file
  449. **    --------------------------------
  450. **
  451. ** On exit,
  452. **    return value    YES if file can be accessed and can be written to.
  453. **
  454. ** Bugs:
  455. **    1.    No code for non-unix systems.
  456. **    2.    Isn't there a quicker way?
  457. */
  458.  
  459. #ifdef vms
  460. #define NO_GROUPS
  461. #endif
  462. #ifdef NO_UNIX_IO
  463. #define NO_GROUPS
  464. #endif
  465. #ifdef PCNFS
  466. #define NO_GROUPS
  467. #endif
  468.  
  469. PUBLIC BOOL HTEditable ARGS1 (CONST char *,filename)
  470. {
  471. #ifdef NO_GROUPS
  472.     return NO;        /* Safe answer till we find the correct algorithm */
  473. #else
  474.     int     groups[NGROUPS];    
  475.     uid_t    myUid;
  476.     int        ngroups;            /* The number of groups  */
  477.     struct stat    fileStatus;
  478.     int        i;
  479.         
  480.     if (stat(filename, &fileStatus))        /* Get details of filename */
  481.         return NO;                /* Can't even access file! */
  482.  
  483.     ngroups = getgroups(NGROUPS, groups);    /* Groups to which I belong  */
  484.     myUid = geteuid();                /* Get my user identifier */
  485.  
  486.     if (TRACE) {
  487.         int i;
  488.     printf("File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  489.             (unsigned int) fileStatus.st_mode, fileStatus.st_uid,
  490.         fileStatus.st_gid,
  491.         myUid, ngroups);
  492.     for (i=0; i<ngroups; i++) printf(" %d", groups[i]);
  493.     printf(")\n");
  494.     }
  495.     
  496.     if (fileStatus.st_mode & 0002)        /* I can write anyway? */
  497.         return YES;
  498.     
  499.     if ((fileStatus.st_mode & 0200)        /* I can write my own file? */
  500.      && (fileStatus.st_uid == myUid))
  501.         return YES;
  502.  
  503.     if (fileStatus.st_mode & 0020)        /* Group I am in can write? */
  504.     {
  505.        for (i=0; i<ngroups; i++) {
  506.             if (groups[i] == fileStatus.st_gid)
  507.             return YES;
  508.     }
  509.     }
  510.     if (TRACE) fprintf(stderr, "\tFile is not editable.\n");
  511.     return NO;                    /* If no excuse, can't do */
  512. #endif
  513. }
  514.  
  515.  
  516. /*    Make a save stream
  517. **    ------------------
  518. **
  519. **    The stream must be used for writing back the file.
  520. **    @@@ no backup done
  521. */
  522. PUBLIC HTStream * HTFileSaveStream ARGS1(HTParentAnchor *, anchor)
  523. {
  524.  
  525.     CONST char * addr = HTAnchor_address((HTAnchor*)anchor);
  526.     char *  localname = HTLocalName(addr);
  527.     
  528.     FILE* fp = fopen(localname, "w");
  529.     if (!fp) return NULL;
  530.     
  531.     return HTFWriter_new(fp);
  532.     
  533. }
  534.  
  535.  
  536. /*    Load a document
  537. **    ---------------
  538. **
  539. ** On entry,
  540. **    addr        must point to the fully qualified hypertext reference.
  541. **            This is the physsical address of the file
  542. **
  543. ** On exit,
  544. **    returns        <0        Error has occured.
  545. **            HTLOADED    OK 
  546. **
  547. */
  548. PUBLIC int HTLoadFile ARGS4 (
  549.     CONST char *,        addr,
  550.     HTParentAnchor *,    anchor,
  551.     HTFormat,        format_out,
  552.     HTStream *,        sink
  553. )
  554. {
  555.     char * filename;
  556.     HTFormat format;
  557.     int fd = -1;        /* Unix file descriptor number = INVALID */
  558.     char * nodename = 0;
  559.     char * newname=0;    /* Simplified name of file */
  560.  
  561. /*    Reduce the filename to a basic form (hopefully unique!)
  562. */
  563.     StrAllocCopy(newname, addr);
  564.     filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
  565.     nodename=HTParse(newname, "", PARSE_HOST);
  566.     free(newname);
  567. /*printf("HTLoadFile filename %s\n",filename); /* hess */
  568.     format = HTFileFormat(filename);
  569.  
  570.  
  571.     
  572. #ifdef vms
  573. /* Assume that the file is in Unix-style syntax if it contains a '/'
  574.    after the leading one @@ */
  575.     {
  576.     char * vmsname = strchr(filename + 1, '/') ?
  577.       vms_name(nodename, filename) : filename + 1;
  578.     fd = open(vmsname, O_RDONLY, 0);
  579.     
  580. /*    If the file wasn't VMS syntax, then perhaps it is ultrix
  581. */
  582.     if (fd<0) {
  583.         char ultrixname[INFINITY];
  584.         if (TRACE) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
  585.         sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
  586.         fd = open(ultrixname, O_RDONLY, 0);
  587.         if (fd<0) {
  588.         if (TRACE) fprintf(stderr, 
  589.                    "HTFile: Can't open as %s\n", ultrixname);
  590.         }
  591.     }
  592.     }
  593. #else
  594.  
  595.     free(filename);
  596.     
  597. /*    For unix, we try to translate the name into the name of a transparently
  598. **    mounted file.
  599. **
  600. **    Not allowed in secure (HTClienntHost) situations TBL 921019
  601. */
  602. #ifndef NO_UNIX_IO
  603.     /* @@@@ Need protection here for telnet server but not httpd server */
  604.      
  605.     /* if (!HTClientHost) */ {        /* try local unix file system */
  606.     /* this was mapping a file name 
  607.      * that was already mapped ?? !!     hess
  608.     char * localname = HTLocalName(addr); 
  609.      */
  610.     char * localname = addr; 
  611.     struct stat dir_info;
  612.     
  613. #ifdef GOT_READ_DIR
  614.  
  615. /*              Multiformat handling
  616. **
  617. **    If needed, scan directory to find a good file.
  618. **  Bug:  we don't stat the file to find the length
  619. */
  620.     if ( (strlen(localname) > strlen(MULTI_SUFFIX))
  621.        && (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
  622.                       MULTI_SUFFIX))) {
  623.         DIR *dp;
  624.         struct direct * dirbuf;
  625.  
  626.         float best = NO_VALUE_FOUND;    /* So far best is bad */
  627.         HTFormat best_rep = NULL;    /* Set when rep found */
  628.         struct direct best_dirbuf;    /* Best dir entry so far */
  629.  
  630.         char * base = strrchr(localname, '/');
  631.         int baselen;
  632.  
  633.         if (!base || base == localname) goto forget_multi;
  634.         *base++ = 0;        /* Just got directory name */
  635.         baselen = strlen(base)- strlen(MULTI_SUFFIX);
  636.         base[baselen] = 0;    /* Chop off suffix */
  637.  
  638.         dp = opendir(localname);
  639.         if (!dp) {
  640. forget_multi:
  641.         free(localname);
  642.         return HTLoadError(sink, 500,
  643.             "Multiformat: directory scan failed.");
  644.         }
  645.         
  646.         while (dirbuf = readdir(dp)) {
  647.             /* while there are directory entries to be read */
  648.         if (dirbuf->d_ino == 0) continue;
  649.                 /* if the entry is not being used, skip it */
  650.         
  651.         if (dirbuf->d_namlen > baselen &&      /* Match? */
  652.             !strncmp(dirbuf->d_name, base, baselen)) {    
  653.             HTFormat rep = HTFileFormat(dirbuf->d_name);
  654.             float value = HTStackValue(rep, format_out,
  655.                             HTFileValue(dirbuf->d_name),
  656.                         0.0  /* @@@@@@ */);
  657.             if (value != NO_VALUE_FOUND) {
  658.                 if (TRACE) fprintf(stderr,
  659.                 "HTFile: value of presenting %s is %f\n",
  660.                 HTAtom_name(rep), value);
  661.             if  (value > best) {
  662.                 best_rep = rep;
  663.                 best = value;
  664.                 best_dirbuf = *dirbuf;
  665.                }
  666.             }    /* if best so far */             
  667.          } /* if match */  
  668.             
  669.         } /* end while directory entries left to read */
  670.         closedir(dp);
  671.         
  672.         if (best_rep) {
  673.         format = best_rep;
  674.         base[-1] = '/';        /* Restore directory name */
  675.         base[0] = 0;
  676.         StrAllocCat(localname, best_dirbuf.d_name);
  677.         goto open_file;
  678.         
  679.         } else {             /* If not found suitable file */
  680.         free(localname);
  681.         return HTLoadError(sink, 403,    /* List formats? */
  682.            "Could not find suitable representation for transmission.");
  683.         }
  684.         /*NOTREACHED*/
  685.     } /* if multi suffix */
  686. /*
  687. **    Check to see if the 'localname' is in fact a directory.  If it is
  688. **    create a new hypertext object containing a list of files and 
  689. **    subdirectories contained in the directory.  All of these are links
  690. **      to the directories or files listed.
  691. **      NB This assumes the existance of a type 'struct direct', which will
  692. **      hold the directory entry, and a type 'DIR' which is used to point to
  693. **      the current directory being read.
  694. */
  695.     
  696. /*printf("HTLoadFile localname %s\n",localname); /* hess */
  697.     
  698.     if (stat(localname,&dir_info) == -1) {     /* get file information */
  699.                                    /* if can't read file information */
  700.         if (TRACE) fprintf(stderr, "HTFile: can't stat %s\n", localname);
  701.  
  702.     }  else {        /* Stat was OK */
  703.         
  704.  
  705.         if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
  706.         /* if localname is a directory */    
  707.  
  708.         HTStructured* target;        /* HTML object */
  709.         HTStructuredClass targetClass;
  710.  
  711.         DIR *dp;
  712.         struct direct * dirbuf;
  713.         
  714.         char * logical;
  715.         char * tail;
  716.         
  717.         BOOL present[HTML_A_ATTRIBUTES];
  718.         char * value[HTML_A_ATTRIBUTES];
  719.         
  720.         char * tmpfilename = NULL;
  721.         struct stat file_info;
  722.         
  723.         if (TRACE)
  724.             fprintf(stderr,"%s is a directory\n",localname);
  725.             
  726. /*    Check directory access.
  727. **    Selective access means only those directories containing a
  728. **    marker file can be browsed
  729. */
  730.         if (HTDirAccess == HT_DIR_FORBID) {
  731.             free(localname);
  732.             return HTLoadError(sink, 403,
  733.             "Directory browsing is not allowed.");
  734.         }
  735.  
  736.  
  737.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  738.             char * enable_file_name = 
  739.             malloc(strlen(localname)+ 1 +
  740.              strlen(HT_DIR_ENABLE_FILE) + 1);
  741.             strcpy(enable_file_name, localname);
  742.             strcat(enable_file_name, "/");
  743.             strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  744.             if (stat(enable_file_name, &file_info) != 0) {
  745.             free(localname);
  746.             return HTLoadError(sink, 403,
  747.             "Selective access is not enabled for this directory");
  748.             }
  749.         }
  750.  
  751.  
  752.         dp = opendir(localname);
  753.         if (!dp) {
  754.             free(localname);
  755.             return HTLoadError(sink, 403, "This directory is not readable.");
  756.         }
  757.  
  758.  
  759.  /*    Directory access is allowed and possible
  760.  */
  761.         logical = HTAnchor_address((HTAnchor*)anchor);
  762.         tail = strrchr(logical, '/') +1;    /* last part or "" */
  763.         
  764.         target = HTML_new(anchor, format_out, sink);
  765.         targetClass = *target->isa;    /* Copy routine entry points */
  766.             
  767.           { int i;
  768.             for(i=0; i<HTML_A_ATTRIBUTES; i++)
  769.                 present[i] = (i==HTML_A_HREF);
  770.         }
  771.         
  772.         {
  773.             char * printable = NULL;
  774.             StrAllocCopy(printable, tail);
  775.             HTUnEscape(printable);
  776.             START(HTML_TITLE);
  777.             PUTS(*printable ? printable : "Welcome ");
  778.             PUTS(" directory");
  779.             END(HTML_TITLE);    
  780.     
  781.             START(HTML_H1);
  782.             PUTS(*printable ? printable : "Welcome");
  783.             END(HTML_H1);
  784.             free(printable);
  785.         }
  786.         
  787.                 if (HTDirReadme == HT_DIR_README_TOP)
  788.             do_readme(target, localname);
  789.         
  790.  
  791. #ifdef SORT
  792.         HTBTree * bt = HTBTree_new(strcasecomp);
  793. #endif
  794.         START(HTML_DIR);        
  795.  
  796.         while (dirbuf = readdir(dp)) {
  797.                 /* while there are directory entries to be read */
  798.             if (dirbuf->d_ino == 0)
  799.                     /* if the entry is not being used, skip it */
  800.             continue;
  801.             
  802.             if (!strcmp(dirbuf->d_name,"."))
  803.             continue;      /* skip the entry for this directory */
  804.             
  805.             if (strcmp(dirbuf->d_name,"..") != 0) {
  806.                 /* if the current entry is parent directory */
  807.             if ((*(dirbuf->d_name)=='.') ||
  808.                 (*(dirbuf->d_name)==','))
  809.                 continue;    /* skip those files whose name begins
  810.                         with '.' or ',' */
  811.             } else {
  812.                 if (!*tail) continue; /* No up from top level */
  813.             }
  814.             StrAllocCopy(tmpfilename,localname);
  815.             if (strcmp(localname,"/")) 
  816.                     /* if filename is not root directory */
  817.             StrAllocCat(tmpfilename,"/"); 
  818.             else
  819.             if (!strcmp(dirbuf->d_name,".."))
  820.                 continue;
  821.         /* if root directory and current entry is parent
  822.                     directory, skip the current entry */
  823.             
  824.             StrAllocCat(tmpfilename,dirbuf->d_name);
  825.             /* append the current entry's filename to the path */
  826.             HTSimplify(tmpfilename);
  827.             
  828.             /* Output the directory entry */
  829.         
  830.             START(HTML_LI);
  831.             {
  832.             char * relative;
  833.             char * escaped = HTEscape(
  834.                 dirbuf->d_name, URL_XPALPHAS);
  835.             /* If empty tail, gives absolute ref below */
  836.             relative = (char*) malloc(
  837.                 strlen(tail) + strlen(escaped)+2);
  838.             if (relative == NULL) outofmem(__FILE__, "DirRead");
  839.             sprintf(relative, "%s/%s", tail, escaped);
  840.             value[HTML_A_HREF] = relative;
  841.             (*targetClass.start_element)(
  842.                     target,HTML_A, present, value);
  843.             free(escaped);
  844.             free(relative);
  845.             }
  846.             stat(tmpfilename, &file_info);
  847.             
  848.             if (strcmp(dirbuf->d_name,"..")) {
  849. /* if the current entry is not the parent directory then use the file name */
  850.             PUTS(dirbuf->d_name);
  851.             if (((file_info.st_mode) & S_IFMT) == S_IFDIR) 
  852.                 PUTC('/'); 
  853.             }                
  854.             else {
  855.             /* use name of parent directory */
  856.             char * endbit = strrchr(tmpfilename, '/');
  857.             PUTS("Up to ");
  858.             PUTS(endbit?endbit+1:tmpfilename);
  859.             }    
  860.             END(HTML_A);
  861.             
  862.         } /* end while directory entries left to read */
  863.         
  864.         closedir(dp);
  865.         free(logical);
  866.         free(tmpfilename);
  867.         
  868. #ifdef SORT
  869.         {        /* Read out sorted filenames */
  870.             void * ele = NULL;
  871.             while ( (ele=HTBTree_next(bt, ele) != 0) {
  872.                if (TRACE) fprintf(stderr,
  873.                    "Sorted: %s\n", HTBTree_object(ele);
  874.             /* @@@@@@@@@@@@@@@@@ */
  875.             }
  876.             HTBTree_free(bt);
  877.         }
  878. #endif        
  879.         END(HTML_DIR);
  880.  
  881.         if (HTDirReadme == HT_DIR_README_BOTTOM)
  882.             do_readme(target, localname);
  883.  
  884.         END_TARGET;
  885.         FREE_TARGET;
  886.             
  887.         free(localname);
  888.         return HT_LOADED;    /* document loaded */
  889.         
  890.         } /* end if localname is directory */
  891.     
  892.     } /* end if file stat worked */
  893.     
  894. /* End of directory reading section
  895. */
  896. #endif
  897. open_file:
  898.     fd = open(localname, O_RDONLY, 0);
  899.     if(TRACE) printf ("HTAccess: Opening `%s' gives %d\n",
  900.                 localname, fd);
  901.     if (fd>=0) {        /* Good! */
  902.         if (HTEditable(localname)) {
  903.             HTAtom * put = HTAtom_for("PUT");
  904.         HTList * methods = HTAnchor_methods(anchor);
  905.         if (HTList_indexOf(methods, put) == (-1)) {
  906.             HTList_addObject(methods, put);
  907.         }
  908.         }
  909.     free(localname);
  910.     }
  911.     }  /* local unix file system */
  912. #endif
  913. #endif
  914.  
  915. #ifdef TRY_WAIS 
  916. /* this just a fallback, mosaic could do this load just as well 
  917.  * the problem is that a bogus url could end up here ? what to do ? BUGBUG 
  918.  * hess 
  919.  */
  920. if (fd<0) {
  921.     char *tryaddr = 0; 
  922.         int status ;
  923.     StrAllocCopy(tryaddr, anchor->address); 
  924.     status = HTLoadWAIS(tryaddr, anchor, format_out, sink);
  925.     free(tryaddr); 
  926.     if( status == HT_LOADED) 
  927.         return HT_LOADED;
  928. }
  929. #endif
  930.  
  931. /*    All attempts have failed if fd<0.
  932. */
  933.     if (fd<0) {
  934.         if (TRACE)
  935.         printf("Can't open `%s', errno=%d\n", addr, errno);
  936.     return HTLoadError(sink, 403, "Can't access requested file.");
  937.     }
  938.     
  939.     HTParseSocket(format, format_out, anchor, fd, sink);
  940.     NETCLOSE(fd);
  941.     return HT_LOADED;
  942.  
  943. }
  944.  
  945. /*        Protocol descriptors
  946. */
  947. PUBLIC HTProtocol HTFile = { "file", HTLoadFile, HTFileSaveStream };
  948.  
  949.